home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 6 / Night Owl's Shareware - PDSI-006 - Night Owl Corp (1990).iso / 029a / scc.zip / REG_LOG.SCC < prev    next >
Text File  |  1991-09-11  |  30KB  |  653 lines

  1. #************************************ 
  2. #                                     
  3. #     Software Change Control (SCC)   
  4. #        Version 2.20   09-07-91                           
  5. #                                     
  6. #            Softime Systems          
  7. #             P.O Box 2447            
  8. #     Lake Ronkonkoma LI. NY 11779    
  9. #            (516) 981-8386           
  10. #                                     
  11. # Copyright (c) 1990-91 Walter Erickson
  12. #          ALL RIGHTS RESERVED
  13. #                                     
  14. #   ------------ Header ------------- 
  15. #   --------------------------------- 
  16. #                                     
  17. #   Out LOG               = reg_log.scc
  18. #         type            = LONG
  19. #         day/month/year  = 11/9/1991  
  20. #         hr:min:sec      = 16:32:51  
  21. #                                     
  22. #   In  MASTER (old)      = reg_log.v1
  23. #         lines           = 266
  24. #         length          = 11151       
  25. #         day/month/year  = 11/9/1991  
  26. #         hr:min:sec      = 15:58:4  
  27. #         hash            = 883447
  28. #                                     
  29. #   In  MASTER (new)      = reg_log.v2
  30. #         lines           = 412
  31. #         length          = 16988       
  32. #         day/month/year  = 11/9/1991  
  33. #         hr:min:sec      = 15:58:4  
  34. #         hash            = 1322866
  35. #                                     
  36. #   ------- SCC Build Options ------- 
  37. #                                     
  38. #   Group   Match     = 6
  39. #   Log     Detail    = Yes
  40. #   Strip   End White = No
  41. #   Ignore  Case      = Yes
  42. #   Ignore  White     = Yes
  43. #   Ignore  Numbers   = Yes
  44. #   Ignore  Strings   = Yes
  45. #                                     
  46. #   -------- Ignore Strings --------- 
  47. #                                     
  48. #   String 1 = "Old"
  49. #   String 2 = "New"
  50. #   String 3 = "SCC"
  51. #   String 4 = "CSS"
  52. #   String 5 = "I_Str"
  53. #                                     
  54. #                                     
  55. # User ID# PS2  0000-000000                                  
  56. #************************************ 
  57.  
  58.  
  59. #
  60. #Change 1
  61. #
  62. #0         ... (Old) line place-holder for reg_log.v1
  63. #1,136     ... 136 (New) lines inserted into reg_log.v2
  64. #
  65. +    1:            *** Please Read the following information ***
  66. +    2: 
  67. +    3:   This file must be viewed from within the SCC VIEW utility. Therefor
  68. +    4: start SCC by typing in at the prompt "SCC /v,reg_log.scc" or use SCC
  69. +    5: VIEW menu selection. This will bring up the SCC VIEW utility with this
  70. +    6: file displayed. Then continue reading the following.
  71. +    7: 
  72. +    8:   **** NOTE ****
  73. +    9: 
  74. +   10:   The main difference between Shareware Log and a registered Log is
  75. +   11: the enhanced view log file "reg_log.scc" and a few extra Log build
  76. +   12: options such as "Ignore Strings". The VIEW utility will display this
  77. +   13: Log in an enhanced mode.
  78. +   14:   Please *** NOTE *** this file "reg_log.scc" is just a sample of how
  79. +   15: a enhanced registered type Log looks like.. other than that, all the
  80. +   16: below principles remain the same for a ShareWare generated Log.
  81. +   17: 
  82. +   18:   Invest only 15 minutes of your time, and discover the "Advantage" of
  83. +   19: SCC's small CASE utility and its ease of use. This example log file
  84. +   20: will review a typical SCC generated change LOG.
  85. +   21: 
  86. +   22:   Some of the "LOG" build options set (see above log header) for this
  87. +   23: SCC example VIEW utility are set as:
  88. +   24: 
  89. +   25:      Group  Match     = 6
  90. +   26:      Log    Detail    = Yes
  91. +   27:      Strip  End White = No       strip ending white space from Old/New
  92. +   28:      Ignore Case      = Yes     
  93. +   29:      Ignore White     = Yes
  94. +   30:      Ignore Numbers   = Yes
  95. +   31:      Ignore Strings   = Yes
  96. +   32: 
  97. +   33:      String 1         = "I_Str"  strings to ignore
  98. +   34:      String 2         = "Old"
  99. +   35:      String 3         = "New"
  100. +   36:      String 4         = "SCC"
  101. +   37:      String 5         = "CSS"
  102. +   38: 
  103. +   39:   If you have a color monitor (for the enhanced view), please note:
  104. +   40: 
  105. +   41:   1) Main "text" screen attributes   (foreground/background):
  106. +   42: 
  107. +   43:      o CONTROL      = High  White & Blue  Background.
  108. +   44:      o Old Document = Light White & Blue  Background.
  109. +   45:      o New Document = Yellow      & Blue  Background.
  110. +   46: 
  111. +   47:   2) Cursor line attributes:
  112. +   48: 
  113. +   49:      o Cursor       = Black       & Cyan  Background.
  114. +   50: 
  115. +   51:   3) Left cursor status window attributes:
  116. +   52:      
  117. +   53:      o CONTROL      = Black       & Cyan  Background.
  118. +   54:      o Common Lines = High  White & Black Background.
  119. +   55:      o Old Document = High  White & Black Background.
  120. +   56:      o New Document = Yellow      & Black Background.
  121. +   57: 
  122. +   58:   4) Lower left status window attributes:
  123. +   59:      When any of the above options are set (= Yes) and the SCC log
  124. +   60:      line cursor position matches a set option or any other condition,
  125. +   61:      the VIEW status line will indicate same.
  126. +   62: 
  127. +   63:      "Ignore   Strings  " a selected ignore "string" was found.
  128. +   64:      "Ignore   White Sp " white space was ignored between lines.
  129. +   65:      "Ignore   Numbers  " numbers was ignored between lines.
  130. +   66:      "Ignore   Case     " upper/lower case was considered equal.
  131. +   67:      "Multi    Opt Match" two or more options were necessary to match.
  132. +   68:      "Moved    Line     " exact matching lines between documents.
  133. +   69:      "Common   Lines    " common lines (with line #) between documents.
  134. +   70:      "Deleted  Line     " old line (deleted)  from the document.
  135. +   71:      "Inserted Line     " new line (inserted) into the document.
  136. +   72:      "Close    Match    " test lines are similar (best guess).
  137. +   73:      "Range    Move     " exact matching lines between documents
  138. +   74:                           but in another change group.
  139. +   75: 
  140. +   76:   5) Lower left cursor compare lines window attributes:
  141. +   77: 
  142. +   78:      o Cursor       = Black       & Cyan  Background.
  143. +   79: 
  144. +   80:   6) Lower left compare lines window character annotations:
  145. +   81: 
  146. +   82:      o Common Lines = High  White & Black  Background.
  147. +   83:      o Common Lines = Yellow      & Black  Background.
  148. +   84: 
  149. +   85: 
  150. +   86:         Note... there are two cursor "tracking" status windows on
  151. +   87:      the left side of the screen. The status window within the cursor
  152. +   88:      position will show special symbol that reflects SCC Log control
  153. +   89:      operations, such characters as  '-', '+', '.' or blank ' '. The
  154. +   90:      status on the lower left of the screen will show what type of
  155. +   91:      operation SCC "change" control took place.
  156. +   92:         If the cursor status equals a blank character ' ' the cursor
  157. +   93:      either will be located either on a SCC Log control line or within
  158. +   94:      the document text. The following examples will follow only the
  159. +   95:      cursor position within the SCC Log document text.
  160. +   96: 
  161. +   97:      
  162. +   98:         When the cursor is on a Log line (the left control side) that
  163. +   99:      has either '-', or '+', then one of the following line operations
  164. +  100:      will apply.
  165. +  101: 
  166. +  102:      
  167. +  103:      Log status   Operation              Flip 
  168. +  104:      ----------   ---------              ----
  169. +  105:             '-'   " Deleted  Line    "   No
  170. +  106:             '+'   " Inserted Line    "   No
  171. +  107:      '-' or '+'   " Close    Match   "   Yes
  172. +  108:      '-' or '+'   " Range    Move    "   Yes
  173. +  109: 
  174. +  110: 
  175. +  111:         When the cursor is on a Log line (the left control side) that
  176. +  112:      equals a blank character ' 'one of the following line operations
  177. +  113:      apply. This greatly simplifies the reading of the printed Log,
  178. +  114:      thus helping to eliminate (unimportant) selected changes.
  179. +  115: 
  180. +  116: 
  181. +  117:      Log status   Operation              Flip 
  182. +  118:      ----------   ---------              ----
  183. +  119:             ' '   " Moved  Line      "   Yes
  184. +  120:             ' '   " Ignore Strings   "   Yes
  185. +  121:             ' '   " Ignore White Sp  "   Yes
  186. +  122:             ' '   " Ignore Numbers   "   Yes
  187. +  123:             ' '   " Ignore Case      "   Yes
  188. +  124:             ' '   " Multi  Opt Match "   Yes
  189. +  125: 
  190. +  126:      
  191. +  127:         When the cursor is on a Log line (the left control side) that
  192. +  128:      has a period '.', then that line is common to both the files Old
  193. +  129:      and New.
  194. +  130: 
  195. +  131: 
  196. +  132:      Log status   Operation              Flip 
  197. +  133:      ----------   ---------              ----
  198. +  134:             '.'   " Common Lines     "   No    New line # shown
  199. +  135: 
  200. +  136: 
  201.  . 137:         The above SCC Log status windows (along with different SCC Log
  202.  . 138:      option settings) can help generate a "filtered" SCC change control
  203.  . 139:      report Log to what is important (delete or insert status) and not
  204.  . 140:      important (blank status) in your file.
  205.  . 141:         For example you may not want the '-' or '+' (delete or insert)
  206.  . 142:      Log status characters for such lines containing differences of 
  207.  . 143:      only "White Space", "Upper/Lower Case" etc.
  208.  . 144: 
  209.  . 145:      At any time you may press the
  210.  . 146:             F1 key for the       help menu.
  211.  . 147:             F2 key for the QUICK help menu.
  212.  . 148: 
  213.  . 149: 
  214.  . 150: 
  215.  . 151: 
  216.  . 152:   START OF EXAMPLES.....
  217. #
  218. #Change 2
  219. #
  220. #17,24     ... 8 (Old) lines deleted  from reg_log.v1
  221. #153,156   ... 4 (New) lines inserted into reg_log.v2
  222. #
  223. -         The following changes without SCC could be extrenely difficult (and
  224. -            costly) to find. Try fliping between versions(Cnt 'M' key) to help
  225. -            amplify how a small change could have been ezsley overlooked.
  226. -            Ww%(123)*(4)[index]A.x,b.7(.Bc)Cd.()*,+|DeEf|FgGh\@$,#&|!\+(0)
  227. -         " Range Move      "
  228. -            This line is a (Range Move).
  229. -         " Deleted  Lines  "
  230. -            Will show what line and line # that was deleted from the Old.
  231. +  153:   The following changes without SCC could be extremely difficult (and
  232. +  154:      costly) to find. Try flipping between versions(Cnt 'V' key) to help
  233. +  155:      amplify how a small change could have been easily overlooked.
  234. +  156:      Ww%(123)*(4)[index]A.x,b.7(.Bc)Cd.()*,+|DeEf|FgGh\@$.#&|!\+(0)
  235.  . 157:   " Common Lines    "
  236.  . 158:      Common Line numbers between the Old and New documents. Cursor
  237.  . 159:      status will show the corresponding Old line #.
  238.  . 160: 
  239.  . 161: 
  240.  . 162: 
  241.  . 163: 
  242.  . 164: 
  243. #
  244. #Change 3
  245. #
  246. #33,60     ... 28 (Old) lines deleted  from reg_log.v1
  247. #165,196   ... 32 (New) lines inserted into reg_log.v2
  248. #
  249.           " Moved  Lines    "
  250.              These are exact matching lines between documents but may have
  251.              different line numbers. NOTE... whenever the "lower" status window
  252.              has two line numbers, you can Flip between documents by pressing
  253.              either Cnt 'V' or Cnt 'M' keys.
  254.           " Ignore I_Str Strings "
  255.              All the text match except for selected "strings" between the New
  256.              and Old documents.
  257.           " Ignore W h i t e Sp "
  258.              All the    text match e xcept for   white space between documents.
  259.           " IGNORE CASE     "
  260.              All The Text Match Except For UPPER/lower Case between documents.
  261.           " MULTI I_Str MATCH    "
  262.              All the TEXT match by using Two or more options between the New
  263.              and Old documents. For example if the option "IGNORE CASE" and
  264.              "IGNORE string" allowed the I_Str lines match t h e n this status.
  265. -         " Close    Matchs"
  266. -            Will show what lines and line # that closley matches between
  267. -            the old & new documents
  268.           " Ignore  Numbers "
  269.              654321 All the text match except for numbers between documents.
  270.           Strip End White                    
  271.                If "Strip End White" was selected the following lines will be   
  272.              exactly alike (same length) and would show as "Common Lines".          
  273.                If "Strip End White" was ** NOT ** selected then the lines    
  274.              will be of different lengths.        
  275.              Watch the cursor by flipping (Cnt 'V' or Cnt 'M' keys) between
  276.              documents.      
  277.    165:   " Ignore  Strings "
  278.    166:      All the text match except for selected "strings" between the Old
  279.    167:      and New documents.
  280. +  168:   " Inserted Lines  "
  281. +  169:      Will show what line and line # that was inserted into the New.
  282. +  170:   " Range Move      "
  283. +  171:      This line is a (Range Move).
  284.    172:   " Ignore White Sp "
  285.    173:      All the text match except for white space between documents.
  286.    174:   " Ignore 1234 Numbers "
  287.    175:      4321 All the text match except for numbers 5678between documents.
  288.    176:   " Ignore Case     "
  289.    177:      All the text match except for upper/lower case between documents.
  290.    178:   " Multi  Match    "
  291.    179:      All the TEXT match by using two or more options between the Old
  292.    180:      and New documents. For example if the option "Ignore Case" and
  293.    181:      "Ignore string" allowed the lines match then this status.
  294.    182:   " Moved  Lines    "
  295.    183:      These are exact matching lines between documents but may have
  296.    184:      different line numbers. NOTE... whenever the "lower" status window
  297.    185:      has two line numbers, you can Flip between documents by pressing
  298.    186:      either Cnt 'V' or Cnt 'M' keys.
  299. +  187:   " Close    Match  "
  300. +  188:      Will show what lines and line #'s that closely matches between
  301. +  189:      the Old/New documents.
  302.    190:   Strip End White        
  303.    191:        If "Strip End White" was selected the following lines will be
  304.    192:      exactly alike (same length) and would show as "Common Lines".
  305.    193:        If "Strip End White" was ** NOT ** selected then the lines
  306.    194:      will be of different lengths.
  307.    195:      Watch the cursor by flipping (Cnt 'V' or Cnt 'M' keys) between 
  308.    196:      documents.
  309.  . 197:   Common lines
  310.  . 198:      These lines are common between the Old and New documents.
  311.  . 199: 
  312.  . 200:   ** Note ** SCC can also track and VIEW any (ASCII TEXT)
  313.  . 201:      formatted document such as the following.
  314.  . 202: 
  315.  . 203: 
  316.  . 204: 
  317.  . 205: 
  318.  . 206: Page 1                         Overview.scc
  319.  . 207: 
  320.  . 208:                       Software Change Control (SCC)
  321.  . 209: 
  322. #
  323. #Change 4
  324. #
  325. #74,77     ... 4 (Old) lines deleted  from reg_log.v1
  326. #210,213   ... 4 (New) lines inserted into reg_log.v2
  327. #
  328. -                                    Softtime Systems
  329.                                        P.O. Box 2447
  330. -                                Lk Ronknnkoma LI. NY 11779
  331. -                                       516 981-8386
  332. +  210:                               Softime Systems
  333.    211:                                P.O. Box 2447
  334. +  212:                        Lake Ronkonkoma LI. NY 11779
  335. +  213:                               (516) 981-8386
  336.  . 214: 
  337.  . 215:                   Copyright (c) 1990-91 by Walter Erickson
  338.  . 216:                            All Rights Reserved.
  339.  . 217: 
  340.  . 218: 
  341.  . 219:                       "A small CASE for a big problem"
  342. #
  343. #Change 5
  344. #
  345. #84,90     ... 7 (Old) lines deleted  from reg_log.v1
  346. #220,231   ... 12 (New) lines inserted into reg_log.v2
  347. #
  348.         Page 1
  349.                                          OVERVIEW 
  350. -                                  Questions "about" SCC
  351. -                                      What is SCC .
  352.         
  353. -         Software Change Control SCC, as the name implies, is one of the most
  354. -       powerful an cost-effective tool in this energing field of CASE.
  355. +  220:                               Mary J Erickson
  356.    221: 
  357. +  222: 
  358. +  223: 
  359.    224: Page 2
  360.    225:                                  Overview 
  361. +  226:                         Common questions about SCC
  362. +  227: 
  363. +  228:                                What is SCC ?
  364. +  229:                                -------------
  365. +  230:   Software Change Control (SCC), as the name implies, is one of the most
  366. +  231: powerful and cost-effective tool available in this emerging field of CASE.
  367.  . 232: SCC features friendly menu-driven interfaces (with automatic context help)
  368.  . 233: suitable for use by non-technical administrative, as well as for the
  369.  . 234: sophisticated user.
  370.  . 235: 
  371.  . 236:   SCC closely tracks (logs) all software/text changes between two similar
  372.  . 237: source files, thereby giving a complete (version to version) audit trail.
  373.  . 238: 
  374.  . 239:   A SCC generated Log greatly simplifies any user request for the
  375.  . 240: (identification) of what, when and why changes were made.
  376.  . 241: 
  377. #
  378. #Change 6
  379. #
  380. #101,104   ... 4 (Old) lines deleted  from reg_log.v1
  381. #242,245   ... 4 (New) lines inserted into reg_log.v2
  382. #
  383.                                     What does CSS do ?
  384.                                     ------------------
  385. -         When SCC is run the tracking (output) log file will then reflect
  386. -       (context) what changes have occurred between the two source files,
  387.    242:                             What does SCC do ?
  388.    243:                             ------------------
  389. +  244:   When SCC is run the tracking (output) log file will then reflect (in
  390. +  245: context) what changes have occurred between the two (input) source files,
  391.  . 246: thus allowing the programmer and/or management to have a clear visual SCC
  392.  . 247: log of all software and/or text changes.
  393.  . 248: 
  394.  . 249:   This feature enables the user to control all enhancements and
  395.  . 250: documentation of source data at this critical level.
  396.  . 251: 
  397.  . 252:                             Why is SCC needed ?
  398.  . 253:                             -------------------
  399.  . 254:   All software source files will need changes. In fact, it is a truism that
  400.  . 255: every software project released, including those released quite recently,
  401.  . 256: need changes. The most important consideration at this stage is to regulate
  402.  . 257: and control the documentation and its changes.
  403.  . 258: 
  404.  . 259:   SCC is a decomposition process that offers a complete and precise
  405.  . 260: description of what (line-by-line) changes have occurred between two source
  406.  . 261: files. This results in faster development time, along with software that is
  407.  . 262: far less likely to fail in use.
  408.  . 263: 
  409.  . 264: Page 3
  410.  . 265:                           Can managers use SCC ?
  411.  . 266:                           ----------------------
  412. #
  413. #Change 7
  414. #
  415. #126,134   ... 9 (Old) lines deleted  from reg_log.v1
  416. #267,275   ... 9 (New) lines inserted into reg_log.v2
  417. #
  418.           Using SCC creates an environment that is very time and cost effective.
  419.         SCC allows changes to be made in a more maintainable, reliable and
  420.         controllable way; that is, software control is fully documented, along with
  421.         a full audit trail of what changes have occurred between software versions.
  422.         
  423.           The management of software changes at the programming (source) level
  424.         (generally accepted as the most expensive and weakest link in software
  425.         management) is one of the most difficult problems managers and programmers
  426.         alike have.
  427.    267:   The management of software changes at the programming (source) level
  428.    268: (generally accepted as the most expensive and weakest link in software
  429.    269: management) is one of the most difficult problems managers and programmers
  430.    270: alike have.
  431.    271: 
  432.    272:   Using SCC creates an environment that is very time and cost effective.
  433.    273: SCC allows changes to be made in a more maintainable, reliable and
  434.    274: controllable way; that is, software control is fully documented, along with
  435.    275: a full audit trail of what changes have occurred between software versions.
  436.  . 276: 
  437.  . 277:   SCC greatly improves the suitability and appropriateness of software
  438.  . 278: change documents; enhances clarity, readability, reliability and complete
  439.  . 279: recoverability; allowing software changes to be a great deal easier to
  440.  . 280: track and maintain.
  441.  . 281: 
  442. #
  443. #Change 8
  444. #
  445. #141,146   ... 6 (Old) lines deleted  from reg_log.v1
  446. #282,287   ... 6 (New) lines inserted into reg_log.v2
  447. #
  448. -                           Does SCC require a speceal editor ?
  449.                             -----------------------------------
  450. -         No, all that's required is that the input source files to CSS be in
  451.         (Ascii TEXT) format.
  452.         
  453.                               Does CSS Require a Data Base ?
  454. +  282:                     Does SCC require a special editor ?
  455.    283:                     -----------------------------------
  456. +  284:   No, all that is required is that the input source files to SCC be in
  457.    285: (ASCII TEXT) format.
  458.    286: 
  459.    287:                       Does SCC require a data base ?
  460.  . 288:                       ------------------------------
  461.  . 289:   No, SCC can either be integrated into a data base or stand alone, for
  462.  . 290: most small projects a data base is not necessary, thus eliminating
  463.  . 291: complexity and cost (KISS). All header file-id, code and documentation
  464.  . 292: changes "between versions" are kept within the SCC Log itself.
  465.  . 293: 
  466.  . 294:                  Can I run SCC against existing versions ?
  467.  . 295:                  -----------------------------------------
  468.  . 296:   Yes, you can build new and complete SCC change logs from older existing
  469.  . 297: (version to version) files, this will give a entire audit trail of any
  470.  . 298: software changes between versions. 
  471.  . 299: 
  472.  . 300:                         What can SCC be used for ?
  473.  . 301:                         --------------------------
  474.  . 302:     o  Documenting
  475. #
  476. #Change 9
  477. #
  478. #162,164   ... 3 (Old) lines deleted  from reg_log.v1
  479. #303,305   ... 3 (New) lines inserted into reg_log.v2
  480. #
  481. -           o  Software control
  482.             o  Software Debugging
  483. -           o  version pre release (development) change control
  484. +  303:     o  Software/text control
  485.    304:     o  Software Debugging
  486. +  305:     o  version pre-release (development) change control
  487.  . 306:     o  Code walkthrough's
  488.  . 307:     o  etc.
  489.  . 308: 
  490.  . 309:                          Using SCC for Documenting
  491.  . 310:                          -------------------------
  492.  . 311:   When SCC is run, the tracking (output) log file will then reflect (in
  493.  . 312: context) what changes that have occurred between the two (input) source
  494.  . 313: files, thus allowing the programmer and/or management to control, enhance
  495.  . 314: and document software at this critical source level.
  496.  . 315: 
  497.  . 316:   SCC generates a software change (log) that closely tracks and records all
  498.  . 317: changes consisting of a header, control change numbers and special symbols
  499.  . 318: to reflect the operations of delete '-', insert '+', move ' ' etc.
  500.  . 319: 
  501. #
  502. #Change 10
  503. #
  504. #179,182   ... 4 (Old) lines deleted  from reg_log.v1
  505. #320,323   ... 4 (New) lines inserted into reg_log.v2
  506. #
  507.         Page 3
  508.                               Using SCC for Software control
  509.                               ------------------------------
  510.           The Manager/Programmer can visually see on one listing (the  CHANGE  Log)
  511.    320: Page 4
  512.    321:                       Using SCC for Software control
  513.    322:                       ------------------------------
  514.    323:   The manager/programmer can visually see on one listing (the change log)
  515.  . 324: all changes and special tracking symbols that were necessary to build the
  516.  . 325: later version from the earlier version, thus keeping an accurate control
  517.  . 326: over all changes.
  518.  . 327: 
  519.  . 328:   SCC will also reveal all unintentional and possible unauthorized changes
  520.  . 329: to source files, thus preventing future problems in the next released
  521.  . 330: version.
  522.  . 331: 
  523.  . 332:   SCC helps the programmer and manager to make changes, "edit out" any
  524.  . 333: tactical coding/design errors between two source files. This can be done by
  525.  . 334: using a similar method such as the following:
  526.  . 335: 
  527.  . 336:   Initial Technical Design Review
  528.  . 337:     o  revision of raw draft coding design
  529.  . 338:     o  clarification of ambiguous design content
  530.  . 339:     o  identification of coding gaps and inconsistencies
  531.  . 340:     o  discovery of major/minor coding errors
  532.  . 341: 
  533. #
  534. #Change 11
  535. #
  536. #201,207   ... 7 (Old) lines deleted  from reg_log.v1
  537. #342,349   ... 8 (New) lines inserted into reg_log.v2
  538. #
  539. -         Coding Review
  540. -           o  verification of content NOT already tested or debugged
  541.             o  incorporation of late technical coding changes
  542. -           o  writing specs for changed docunentation
  543.         
  544.           Final Technical Design Review
  545. -           o  refining the source code for usability
  546. +  342:   Quick Coding Review
  547. +  343:     o  verification of technical content NOT already tested or
  548. +  344:        debugged
  549.    345:     o  incorporation of late technical coding changes
  550. +  346:     o  writing specs for changed documentation
  551.    347: 
  552.    348:   Final Technical Design Review
  553. +  349:     o  refining the source code/documentation for usability
  554.  . 350:     o  minor "edit" cleanup
  555.  . 351:     o  careful configuration control and test proofing
  556.  . 352: 
  557.  . 353:   Field Maintenance of Released Software
  558.  . 354:     o  discovery of unintentional coding errors
  559.  . 355:     o  discovery of undocumented features
  560.  . 356:     o  uncovering code that once worked, but now does not
  561.  . 357:     o  SCC Log header information for release identification and control
  562.  . 358: 
  563.  . 359: Page 5
  564.  . 360:                                 SCC summary
  565.  . 361:                                 -----------
  566. #
  567. #Change 12
  568. #
  569. #219       ... (Old) line place-holder for reg_log.v1
  570. #362,367   ... 6 (New) lines inserted into reg_log.v2
  571. #
  572. +  362:   SCC is a comprehensive utility designed to compare two files and generate
  573. +  363: various reports (log files) that display any or all change differences as
  574. +  364: they evolve.
  575. +  365: 
  576. +  366:   SCC log records who, why, when and where changes were made, thus
  577. +  367: maintaining a complete history of all changes.
  578.  . 368: 
  579.  . 369:   SCC enables detailed verification of auditing accuracy, eliminates
  580.  . 370: undetected programming errors and drastically reduces manual desk checking
  581.  . 371: time.
  582.  . 372: 
  583.  . 373:   The manager/programmer knows exactly what the changes are between
  584.  . 374: versions.
  585. #
  586. #Change 13
  587. #
  588. #227,230   ... 4 (Old) lines deleted  from reg_log.v1
  589. #375,379   ... 5 (New) lines inserted into reg_log.v2
  590. #
  591.           SCC accepts (ASCII TEXT) output from your favored editor.
  592. -         SCC is a comprehensive utility designed to compare two files and generate
  593. -       various reports (log files) that display any or all change differences as
  594. -       they evolve.
  595. +  375: 
  596.    376:   SCC accepts (ASCII TEXT) output from your favored editor.
  597. +  377: 
  598. +  378:   You can build new and complete SCC change logs from older existing
  599. +  379: (version to version) files.
  600.  . 380: 
  601.  . 381:   You can track any coding progress on software changes by viewing an SCC
  602.  . 382: log against the previous and/or developing files.
  603.  . 383: 
  604.  . 384:   You can backtrack to any previous version to examine what changes created
  605.  . 385: that release at that time.
  606.  . 386: 
  607.  . 387: 
  608.  . 388:   SCC change log report (version to version) can greatly help in debugging
  609.  . 389: changes between versions (one works the other does not).
  610.  . 390: 
  611. #
  612. #Change 14
  613. #
  614. #242,250   ... 9 (Old) lines deleted  from reg_log.v1
  615. #391       ... (New) line place-holder for reg_log.v2
  616. #
  617. -         You can build new and complete SCC change logs from older existing
  618. -       (version to version) files.
  619. -       
  620. -         The key benefits of SCC are:
  621. -           o  lower project costs
  622. -           o  controlled release management
  623. -           o  structured walkthroughs
  624. -           o  faster software coding thruput
  625. -           o  higher software quality
  626.  . 391: 
  627.  . 392: 
  628.  . 393:                          ONLY SCC_II "registered"
  629.  . 394:                          ------------------------
  630.  . 395:   You can use the SCC Log to re-create any version (forward or backward),
  631.  . 396: the SCC header ensures integrity, synchronization and recoverability of the
  632.  . 397: reconstructed source.
  633.  . 398: 
  634.  . 399:   By using the SCC "short Log" option, you can better utilize disk storage
  635.  . 400: on your computer. 
  636.  . 401: 
  637. #
  638. #Change 15
  639. #
  640. #261       ... (Old) line place-holder for reg_log.v1
  641. #402,407   ... 6 (New) lines inserted into reg_log.v2
  642. #
  643. +  402:   The key benefits of SCC are:
  644. +  403:     o  lower project costs
  645. +  404:     o  controlled release management
  646. +  405:     o  structured walkthroughs
  647. +  406:     o  faster software coding thruput
  648. +  407:     o  higher software quality
  649.  . 408: 
  650.  . 409:      If you would like further information about this or the SCC registered
  651.  . 410:      programs, please call Walter Erickson at (516) 981-8386
  652.  . 411: 
  653.